Tight coordination is required among development team members in order to deliver a successful software system. Unfortunately, there are several problems inherent in software development projects that make such coordination difficult. Several software characteristics—scale, interdependence, and uncertainty—cause unavoidable coordination problems.
Software systems are becoming increasingly large, thus making complexity and interdependencies between modules of software systems particularly significant characteristics. Often, projects involve millions of lines of code and the development cycle spans multiple years. The size of these projects makes it impossible for any one individual or even a small group of individuals to fully understand all details of the system being developed. When projects become large, it is necessary to divide the development work among several teams of developers. This can create efficiency by allowing teams to work in parallel. However, parallel streams of work must eventually be integrated, which introduces additional coordination needs. Moreover, developers are often separated by geographic, organizational or social boundaries, and these boundaries can create coordination barriers.
Software that has been broken into small components to be developed independently by many teams or developers must eventually be integrated into one deliverable software system. There are often many dependencies between the various components. In order for the end system to function correctly, the components must work together properly. Integration of software must be very precise. Lack of coordination among developers working on dependent components can lead to integration problems.
Software development work is subject to continuous change, That causes many difficulties and produces ongoing coordination needs. Requirements can change over time due to changes in user needs, hardware changes or changing business needs.
These characteristics are inherent in modern software projects and introduce coordination overhead. While steps can be taken to reduce this coordination overhead, the need to coordinate cannot be completely eliminated in any project. Adding more people to project that is already behind schedule further delays the project due to the added project coordination and communication overhead. Coordination can be even more difficult when the involved developers span team boundaries. When cross-boundary dependencies exist, developers often do not coordinate due to a lack of awareness of the importance of the coordination as well as a lack of social relationships across teams. Lack of coordination results in integration problems. Coordination is one of the biggest problems in large software projects. Developers are not always aware of their coordination needs and when developers are unaware of the coordination that is required to manage their work dependencies, problems occur. Studies have found that unfulfilled coordination needs can result in an increase in task resolution time, an increase in software faults, build failures, redundant work, and schedule slips.
Some researchers have developed methods of determining when individual coders should coordinate but the need to coordinate is only identified at the coder level. For example, coder A should coordinate with coder B. Since both coders A and B are usually involved in multiple tasks, this level of information is not actionable. The specific task-pair that they need to coordinate is the required information.
Most software engineering work is done as “tasks.” Tasks are defined as a work assignment given to a specific coder. For example, a task may be to add a certain user requested function to the overall system, or it may be to fix an error that occurs when the system is used. Therefore, a task typically involves multiple files (or artifacts) of the overall system. The task may involve editing certain files, looking at certain files without editing (to make sure that the change in one file will not cause problems in others) or it may involve the creation of new files.
To be actionable, coordination requirements must be identified at the task-pair level of detail. However, if every potential pair of tasks was identified as requiring coordination, information overload would prevent effective coordination. The example of the healthcare.gov website with its 500 million lines of code can shed some light on this potential information overload. Several thousand coders were/are involved in the development of this software system. The number of task-pairs that could potentially require coordination is in the multiple-billions. Therefore, in order to assure that the critical coordination requirement needs are identified, a means to identify those that are critical is required in real time.
Awareness of coordination needs is a critical concern in large software projects. However, too many coordination requirements is the same as having no coordination requirements identified as the information overload causes the alerts to be ignored by software engineers. Thus, any coordination system should have high specificity as well as high sensitivity.
There is a need in the art for a development coordination system that can identify dependencies and coordination needs with high specificity and sensitivity.
Existing configuration management systems attempt to manage coordination requirements but they are limited in that they only manage direct conflicts. That is, the configuration management system will prevent two software engineers from working on the same file of code at the same time. Or, the configuration management system will allow parallel work on the same file and attempt to merge the changes when both engineers are completed their work. However, if code file X has a dependency on code file Y, the configuration management system will not be able to identify the need for engineers to coordinate their work when these files are simultaneously edited.